const app = getApp();
const db = wx.cloud.database();
const _ = db.command;

Page({
    data: {
        userId: '',  // 当前用户的 userId
        UId: '',
        filteredChatroomData: [],
        displayType: '',
        page: 1, // 当前页码，初始为 1
        pageSize: 20 // 每页显示的记录数
    },

    /**
     * 格式化时间戳为本地日期时间字符串
     */
    formatTime: function (timestamp) {
      const date = new Date(timestamp);
      const year = date.getFullYear();
      const month = date.getMonth() + 1;
      const day = date.getDate();
      const hour = date.getHours();
      const minute = date.getMinutes();
      const second = date.getSeconds();

      function formatNumber(n) {
          n = n.toString();
          return n[1] ? n : '0' + n;
      }

      return [year, month, day].map(formatNumber).join('-') + ' ' +
          [hour, minute, second].map(formatNumber).join(':');
  },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {
        console.log("Received UId:", options.UId);
        console.log("Received options:", options);
        this.setData({
            userId: app.globalData.userId,
            UId: options.UId
        });
        this.fetchData();
    },

    /**
     * 根据 UId 获取相应的数据
     */
    fetchData() {
        const { UId, userId, page, pageSize } = this.data;
        let displayType = '';
        switch (UId) {
            case '1':
            case '3':
            case '4':
                displayType ='message';
                break;
            case '2':
                displayType = 'chatroom';
                break;
            default:
                console.log('无效的 UId');
        }
        this.setData({ displayType });

        switch (UId) {
            case '1':
                // 查询 messages 中 userId 是当前用户的发言
                db.collection('messages')
                   .where({
                        senderId: userId
                    })
                   .orderBy('sendTimeTs', 'desc') // 按发送时间降序排列
                   .skip((page - 1) * pageSize) // 跳过前面的记录
                   .limit(pageSize) // 限制返回的记录数
                   .get()
                   .then(res => {
                        if (res.data.length === 0) {
                            wx.showToast({
                                title: '没有更多消息了',
                                icon: 'none'
                            });
                            return;
                        }
                        const formattedData = res.data.map(item => {
                            item.formattedTime = this.formatTime(item.sendTimeTs);
                            return item;
                        });
                        const newFilteredChatroomData = [...this.data.filteredChatroomData, ...formattedData];
                        this.setData({
                            filteredChatroomData: newFilteredChatroomData,
                            page: page + 1 // 页码加 1
                        });
                        console.log("查询获得的消息", formattedData);
                    })
                   .catch(err => {
                        console.error('查询消息失败:', err);
                    });
                break;
            case '2':
                // 查询 chatrooms 中当前用户创建的帖子的聊天室名称
                db.collection('chatrooms')
                   .where({
                        creatorId: userId
                    })
                   .orderBy('createTime', 'desc') // 按创建时间降序排列
                   .skip((page - 1) * pageSize) // 跳过前面的记录
                   .limit(pageSize) // 限制返回的记录数
                   .get()
                   .then(res => {
                        if (res.data.length === 0) {
                            wx.showToast({
                                title: '没有更多聊天室了',
                                icon: 'none'
                            });
                            return;
                        }
                        const newFilteredChatroomData = [...this.data.filteredChatroomData, ...res.data];
                        this.setData({
                            filteredChatroomData: newFilteredChatroomData,
                            page: page + 1 // 页码加 1
                        });
                    })
                   .catch(err => {
                        console.error('查询聊天室失败:', err);
                    });
                break;
            case '3':
                // 查询 userActions 中当前用户的 like 行为，并找到对应的 message
                db.collection('userActions')
                   .where({
                        userId: userId,
                        type: 'like'
                    })
                   .get()
                   .then(res => {
                        const messageIds = res.data.map(action => action.messageId);
                        return db.collection('messages')
                           .where({
                                _id: db.command.in(messageIds)
                            })
                           .orderBy('sendTimeTs', 'desc') // 按发送时间降序排列
                           .skip((page - 1) * pageSize) // 跳过前面的记录
                           .limit(pageSize) // 限制返回的记录数
                           .get();
                    })
                   .then(res => {
                        if (res.data.length === 0) {
                            wx.showToast({
                                title: '没有更多点赞消息了',
                                icon: 'none'
                            });
                            return;
                        }
                        const formattedData = res.data.map(item => {
                            item.formattedTime = this.formatTime(item.sendTimeTs);
                            return item;
                        });
                        const newFilteredChatroomData = [...this.data.filteredChatroomData, ...formattedData];
                        this.setData({
                            filteredChatroomData: newFilteredChatroomData,
                            page: page + 1 // 页码加 1
                        });
                    })
                   .catch(err => {
                        console.error('查询点赞消息失败:', err);
                    });
                break;
            case '4':
                // 查询 userActions 中当前用户的 collect 行为，并找到对应的 message
                db.collection('userActions')
                   .where({
                        userId: userId,
                        type: 'collect'
                    })
                   .get()
                   .then(res => {
                        const messageIds = res.data.map(action => action.messageId);
                        return db.collection('messages')
                           .where({
                                _id: db.command.in(messageIds)
                            })
                           .orderBy('sendTimeTs', 'desc') // 按发送时间降序排列
                           .skip((page - 1) * pageSize) // 跳过前面的记录
                           .limit(pageSize) // 限制返回的记录数
                           .get();
                    })
                   .then(res => {
                        if (res.data.length === 0) {
                            wx.showToast({
                                title: '没有更多收藏消息了',
                                icon: 'none'
                            });
                            return;
                        }
                        const formattedData = res.data.map(item => {
                            item.formattedTime = this.formatTime(item.sendTimeTs);
                            return item;
                        });
                        const newFilteredChatroomData = [...this.data.filteredChatroomData, ...formattedData];
                        this.setData({
                            filteredChatroomData: newFilteredChatroomData,
                            page: page + 1 // 页码加 1
                        });
                    })
                   .catch(err => {
                        console.error('查询收藏消息失败:', err);
                    });
                break;
            default:
                console.log('无效的 UId');
        }
    },

    /**
     * 处理滑动删除事件
     */
    onClose(event) {
        const { position, instance } = event.detail;
        const { index, displayType, roomId, messageId } = event.currentTarget.dataset;
        switch (position) {
            case 'left':
            case 'cell':
                instance.close();
                break;
            case 'right':
                wx.showModal({
                    title: '提示',
                    content: '确定删除吗？',
                    success: (res) => {
                        if (res.confirm) {
                            if (displayType === 'chatroom') {
                                // 删除聊天室及相关数据
                                this.deleteChatroom(roomId, index, instance);
                            } else if (this.data.UId === '3') {
                                // 删除点赞记录并更新消息点赞数
                                this.deleteLikeAction(messageId, index, instance);
                            } else if (this.data.UId === '4') {
                                // 删除收藏记录并更新消息收藏数
                                this.deleteCollectAction(messageId, index, instance);
                            } else {
                                // 删除消息
                                this.deleteMessage(messageId, index, instance);
                            }
                        } else {
                            instance.close();
                        }
                    }
                });
                break;
        }
    },

    /**
     * 删除聊天室及相关数据
     */
    deleteChatroom(roomId, index, instance) {
        const db = wx.cloud.database();
        const _ = db.command;

        // 删除 chatroomMembers 数据
        db.collection('chatroomMembers')
           .where({
                roomId: roomId
            })
           .remove()
           .then(() => {
                // 删除 userActions 中与该聊天室消息相关的数据
                return db.collection('messages')
                   .where({
                        roomId: roomId
                    })
                   .field({
                        _id: true
                    })
                   .get()
                   .then(res => {
                        const messageIds = res.data.map(item => item._id);
                        return db.collection('userActions')
                           .where({
                                messageId: _.in(messageIds)
                            })
                           .remove();
                    });
            })
           .then(() => {
                // 删除 messages 数据
                return db.collection('messages')
                   .where({
                        roomId: roomId
                    })
                   .remove();
            })
           .then(() => {
                // 删除 chatroom 数据
                return db.collection('chatrooms')
                   .doc(roomId)
                   .remove();
            })
           .then(() => {
                // 更新页面数据
                const filteredChatroomData = this.data.filteredChatroomData;
                filteredChatroomData.splice(index, 1);
                this.setData({
                    filteredChatroomData: filteredChatroomData
                });
                instance.close();

                // 调用 /pages/chat_forum/chat_forum 页面的刷新方法
                const pages = getCurrentPages();
                for (let i = pages.length - 1; i >= 0; i--) {
                    const page = pages[i];
                    if (page.route === 'pages/chat_forum/chat_forum') {
                        if (typeof page.refreshData === 'function') {
                            page.refreshData();
                        }
                        break;
                    }
                }
            })
           .catch(err => {
                console.error('删除聊天室失败:', err);
                instance.close();
            });
    },

    /**
     * 删除消息
     */
    deleteMessage(messageId, index, instance) {
        // 删除 userActions 中与该消息相关的数据
        db.collection('userActions')
           .where({
                messageId: messageId
            })
           .remove()
           .then(() => {
                // 删除消息数据
                return db.collection('messages')
                   .doc(messageId)
                   .remove();
            })
           .then(() => {
                // 更新页面数据
                const filteredChatroomData = this.data.filteredChatroomData;
                filteredChatroomData.splice(index, 1);
                this.setData({
                    filteredChatroomData: filteredChatroomData
                });
                instance.close();
            })
           .catch(err => {
                console.error('删除消息失败:', err);
                instance.close();
            });
    },

    /**
     * 删除点赞记录并更新消息点赞数
     */
    deleteLikeAction(messageId, index, instance) {
        // 删除 userActions 中与该消息相关的点赞记录
        db.collection('userActions')
           .where({
                messageId: messageId,
                userId: this.data.userId,
                type: 'like'
            })
           .remove()
           .then(() => {
                // 更新消息的 likeCount 减 1
                return db.collection('messages')
                   .doc(messageId)
                   .update({
                        data: {
                            likeCount: _.inc(-1)
                        }
                    });
            })
           .then(() => {
                // 更新页面数据
                const filteredChatroomData = this.data.filteredChatroomData;
                filteredChatroomData.splice(index, 1);
                this.setData({
                    filteredChatroomData: filteredChatroomData
                });
                instance.close();
            })
           .catch(err => {
                console.error('删除点赞记录失败:', err);
                instance.close();
            });
    },

    /**
     * 删除收藏记录并更新消息收藏数
     */
    deleteCollectAction(messageId, index, instance) {
        // 删除 userActions 中与该消息相关的收藏记录
        db.collection('userActions')
           .where({
                messageId: messageId,
                userId: this.data.userId,
                type: 'collect'
            })
           .remove()
           .then(() => {
                // 更新消息的 collectCount 减 1
                return db.collection('messages')
                   .doc(messageId)
                   .update({
                        data: {
                            collectCount: _.inc(-1)
                        }
                    });
            })
           .then(() => {
                // 更新页面数据
                const filteredChatroomData = this.data.filteredChatroomData;
                filteredChatroomData.splice(index, 1);
                this.setData({
                    filteredChatroomData: filteredChatroomData
                });
                instance.close();
            })
           .catch(err => {
                console.error('删除收藏记录失败:', err);
                instance.close();
            });
    },

    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady() {

    },

    /**
     * 生命周期函数--监听页面显示
     */
    onShow() {

    },

    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide() {

    },

    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload() {

    },

    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh() {

    },

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom() {
        this.fetchData();
    },

    /**
     * 用户点击右上角分享
     */
    onShareAppMessage() {

    }
});